﻿//using System;
//using System.Collections;
//using System.Collections.Generic;

///// <summary>
///// 依赖注入中的配置项（注入容器）
///// </summary>
//public class MapItem  {

//    private Boolean _singleton = true;
//    private Dictionary<String, String> _maps = new Dictionary<String, String>();

//    /// <summary>
//    /// 容器创建对象的时候，是否以单例模式返回
//    /// </summary>
//    public Boolean Singleton
//    {
//        get { return _singleton; }
//        set { _singleton = value; }
//    }

//    /// <summary>
//    /// 对象依赖注入关系的 map
//    /// </summary>
//    public Dictionary<String, String> Map
//    {
//        get { return _maps; }
//        set { _maps = value; }
//    }

//    /// <summary>
//    /// 对象的 typeFullName
//    /// </summary>
//    public String Type { get; set; }

//    /// <summary>
//    /// 添加注入关系
//    /// </summary>
//    /// <param name="propertyName">属性名称</param>
//    /// <param name="item">注入容器</param>
//    internal void AddMap(String propertyName, MapItem item)
//    {
//        AddMap(propertyName, item.Name);
//    }

//    /// <summary>
//    /// 注入
//    /// </summary>
//    /// <param name="propertyName">属性名称</param>
//    /// <param name="injectBy">对象名称</param>
//    internal void AddMap(String propertyName, String injectBy)
//    {
//        this.Map.Add(propertyName, injectBy);
//    }


//    private Object _obj;
//    /// <summary>
//    /// 目标对象
//    /// </summary>
//    [NotSave]
//    internal Object TargetObject
//    {
//        get { return _obj; }
//        set { _obj = value; }
//    }

//    private Type _type;

//    /// <summary>
//    /// 目标类型
//    /// </summary>
//    [NotSave]
//    internal Type TargetType
//    {
//        get
//        {

//            if (_type != null) return _type;
//            if (TargetObject != null) return TargetObject.GetType();
//            return null;
//        }
//        set { _type = value; }
//    }

//    /// <summary>
//    /// 创建一个经过Ioc处理的对象，结果不是单例。
//    /// 检测是否需要注入。
//    /// </summary>
//    /// <typeparam name="T"></typeparam>
//    /// <returns></returns>
//    public static T Create<T>()
//    {
//        return (T)CreateObject(typeof(T), null);
//    }

//    /// <summary>
//    /// 创建一个经过Ioc处理的对象，结果不是单例。
//    /// 检测是否需要注入。
//    /// </summary>
//    /// <param name="targetType"></param>
//    /// <param name="invokerName">如果是根据接口自动装配，</param>
//    /// <returns></returns>
//    private static Object CreateObject(Type targetType, Object invoker)
//    {

//        if (targetType == null) return null;

//        if (targetType.IsInterface)
//        {
//            ///接口
//            return CreateByInterface(targetType, invoker);
//        }
//        //这里是用AOP实现对象的构建，可以参看上一篇博客
//        Object objTarget = AopContext.CreateObjectBySub(targetType);
//        //进行IOC注入
//        Inject(objTarget);
//        return objTarget;
//    }
//    /// <summary>
//    /// 根据容器配置(IOC)，将依赖关系注入到已创建的对象中
//    /// </summary>
//    /// <param name="obj"></param>
//    public static void Inject(Object obj)
//    {
//        if (obj == null) return;
//        Type t = obj.GetType();
//        MapItem mapItem = getMapItemByType(t);
//        if (mapItem == null)
//        {
//            mapItem = new MapItem();
//            mapItem.TargetType = t;
//            mapItem.TargetObject = obj;
//        }

//        createInstanceAndInject(mapItem, obj);

//    }
//    /// <summary>
//    /// 根据类型查找DI容器
//    /// </summary>
//    /// <param name="t"></param>
//    /// <returns></returns>
//    private static MapItem getMapItemByType(Type t)
//    {

//        Dictionary<String, MapItem> resolvedMap = Instance.ResolvedMap;//当前对象的键值对容器
//        foreach (KeyValuePair<String, MapItem> entry in resolvedMap)
//        {
//            MapItem item = entry.Value;
//            if (t.FullName.Equals(item.Type)) return item;
//        }
//        return null;
//    }

//    /// <summary>
//    /// IOC注入：检查对象的属性，根据配置注入，如果没有配置，则自动装配
//    /// </summary>
//    /// <param name="mapItem"></param>
//    /// <returns></returns>
//    private static Object createInstanceAndInject(MapItem mapItem, Object objTarget)
//    {

//        Type targetType = mapItem.TargetType;
//        if (targetType.IsAbstract)
//        {
//            logger.Info("type is abstract=>" + targetType.FullName);
//            return null;
//        }

//        if (objTarget == null)
//        {
//            objTarget = rft.GetInstance(targetType);//根据反射创建对象
//        }

//        // 检查所有属性
//        PropertyInfo[] properties = targetType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
//        foreach (PropertyInfo p in properties)
//        {
//            if (!p.CanRead) continue;
//            if (!p.CanWrite) continue;

//            // 不是接口的跳过
//            if (!p.PropertyType.IsInterface) continue;


//            // 对接口进行注入检查
//            //-------------------------------------------------

//            // 如果有注入配置
//            Object mapValue = getMapValue(mapItem.Map, p);
//            if (mapValue != null)
//            {
//                p.SetValue(objTarget, mapValue, null);
//            }
//            // 如果没有注入
//            else
//            {
//                Object propertyValue = p.GetValue(objTarget, null);
//                // 自动装配
//                if (propertyValue == null)
//                {

//                    logger.Info("property=>" + targetType.Name + "." + p.Name);

//                    propertyValue = getAutoWiredValue(p.PropertyType);
//                    if (propertyValue != null)
//                    {
//                        p.SetValue(objTarget, propertyValue, null);
//                    }
//                    else
//                    {
//                        logger.Info("property is null=>" + p.Name);
//                    }
//                }
//            }


//        }


//        return objTarget;
//    }




//    // IOC注入：检查对象的属性，根据配置注入，如果没有配置，则自动装配
//    private static Object createInstanceAndInject(MapItem mapItem)
//    {
//        return createInstanceAndInject(mapItem, null);
//    }
//    /// <summary>
//    /// 检查映射关系中是否存在属性信息
//    /// </summary>
//    /// <param name="maps"></param>
//    /// <param name="p"></param>
//    /// <returns></returns>
//    private static Object getMapValue(Dictionary<String, String> maps, PropertyInfo p)
//    {

//        if (maps == null || maps.Count == 0) return null;

//        foreach (KeyValuePair<String, String> entry in maps)
//        {
//            Object x = GetByName(entry.Value);
//            if (x != null) return x;
//        }
//        return null;
//    }
//    /// <summary>
//    /// 根据依赖注入的配置文件中的 name 获取对象。根据配置属性Singleton决定是否单例。
//    /// </summary>
//    /// <param name="objectName"></param>
//    /// <returns></returns>
//    public static Object GetByName(String objectName)
//    {

//        if (Instance.ResolvedMap.ContainsKey(objectName) == false) return null;

//        MapItem item = Instance.ResolvedMap[objectName];
//        if (item == null) return null;

//        if (item.Singleton)
//            return Instance.ObjectsByName[objectName];
//        else
//            return createInstanceAndInject(item);
//    }



//    // 根据接口，获取自动绑定的值
//    private static Object getAutoWiredValue(Type interfaceType)
//    {

//        List<Type> typeList = GetTypeListByInterface(interfaceType);
//        if (typeList.Count == 0)
//        {
//            return null; // 返回null
//        }
//        else if (typeList.Count == 1)
//        {
//            return Create(typeList[0], interfaceType);
//        }
//        else
//        {
//            StringBuilder msg = new StringBuilder();
//            foreach (Type t in typeList)
//            {
//                msg.Append(t.FullName + ",");
//            }
//            throw new Exception(string.Format("有多个接口实现，接口={0}，实现={1} 没有明确指定，无法自动注入。", interfaceType.FullName, msg));
//        }
//    }

//    // 根据接口获取实例
//    public static List<Type> GetTypeListByInterface(Type interfaceType)
//    {

//        List<Type> typeList = new List<Type>();
//        foreach (KeyValuePair<String, Type> kv in Instance.TypeList)
//        {

//            if (rft.IsInterface(kv.Value, interfaceType))
//            {
//                typeList.Add(kv.Value);
//            }
//        }

//        return typeList;
//    }






//}

//public class NotSave : Attribute
//{

//}